package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade PONTO_EXECUCAO
 * @author Gerado pelo Telescope
 */
public class EntPontoExecucao extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.PONTO_EXECUCAO";
    public final static String TABLE_NAME = "PONTO_EXECUCAO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntPontoExecucao() {
        super();
        initialize();
    }
    
    public EntPontoExecucao(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aSigla = new DomText(this,"SIGLA", "Sigla do ponto de ensaio"); 
        aSigla.setRequired(true);
        aSigla.setSize(6);
        oSigla = new DomText();
        aDescricao = new DomTextLong(this,"DESCRICAO", "Descrição do ponto de ensaio"); 
        aDescricao.setSize(512);
        oDescricao = new DomTextLong();
        aErroRegulagemMinima = new DomPercent(this,"ERRO_REGULAGEM_MINIMA", "% de erro (regulagem mínima)"); 
        aErroRegulagemMinima.setRequired(true);
        oErroRegulagemMinima = new DomPercent();
        aErroRegulagemMaxima = new DomPercent(this,"ERRO_REGULAGEM_MAXIMA", "% de erro (regulagem máxima)"); 
        aErroRegulagemMaxima.setRequired(true);
        oErroRegulagemMaxima = new DomPercent();
        aCampoMedicao = new DomOption(this,"CAMPO_MEDICAO", "Campo de medição"); 
        aCampoMedicao.setRequired(true);
        aCampoMedicao.setSize(1);
        aCampoMedicao.clearOptions();
        aCampoMedicao.addOption("I", "Faixa Inferior");
        aCampoMedicao.addOption("S", "Faixa Superior");
        oCampoMedicao = new DomOption();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Sigla do ponto de ensaio
    private DomText aSigla;
    private DomText oSigla;
    
    // Descrição do ponto de ensaio
    private DomTextLong aDescricao;
    private DomTextLong oDescricao;
    
    // % de erro (regulagem mínima)
    private DomPercent aErroRegulagemMinima;
    private DomPercent oErroRegulagemMinima;
    
    // % de erro (regulagem máxima)
    private DomPercent aErroRegulagemMaxima;
    private DomPercent oErroRegulagemMaxima;
    
    // Campo de medição
    private DomOption aCampoMedicao;
    private DomOption oCampoMedicao;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntPontoExecucao id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SIGLA">
    
    public EntPontoExecucao sigla(String value) {
        setSigla(value);
        return this;
    }
    
    public void setSigla(DomText value) {
        if (value == null || value.isNull()) {
            nullifySigla();
        } else {
            aSigla.setValue(value.getValue());
            if (aSigla.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSigla(String value) {
        if (value == null) {
            nullifySigla();
        } else {
            aSigla.setValue(value);
            if (aSigla.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSigla(Object value) {
        aSigla.setValue(value);
        if (aSigla.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySigla() {
        if (!aSigla.isNull()) {
            aSigla.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getSigla() {
        return aSigla;
    }
    
    public DomText oldSigla() {
        return oSigla;
    }
    
    public String valueOfSigla() {
        return aSigla.getValue();
    }
    
    public boolean isSiglaModified() {
        return aSigla.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESCRICAO">
    
    public EntPontoExecucao descricao(String value) {
        setDescricao(value);
        return this;
    }
    
    public void setDescricao(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value.getValue());
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(String value) {
        if (value == null) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value);
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(Object value) {
        aDescricao.setValue(value);
        if (aDescricao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDescricao() {
        if (!aDescricao.isNull()) {
            aDescricao.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getDescricao() {
        return aDescricao;
    }
    
    public DomTextLong oldDescricao() {
        return oDescricao;
    }
    
    public String valueOfDescricao() {
        return aDescricao.getValue();
    }
    
    public boolean isDescricaoModified() {
        return aDescricao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ERRO_REGULAGEM_MINIMA">
    
    public EntPontoExecucao erroRegulagemMinima(Double value) {
        setErroRegulagemMinima(value);
        return this;
    }
    
    public void setErroRegulagemMinima(DomPercent value) {
        if (value == null || value.isNull()) {
            nullifyErroRegulagemMinima();
        } else {
            aErroRegulagemMinima.setValue(value.getValue());
            if (aErroRegulagemMinima.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setErroRegulagemMinima(String value) {
        if (value == null) {
            nullifyErroRegulagemMinima();
        } else {
            aErroRegulagemMinima.setValue(value);
            if (aErroRegulagemMinima.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setErroRegulagemMinima(Double value) {
        aErroRegulagemMinima.setValue(value);
        if (aErroRegulagemMinima.isModified()) {
            setModified(true);
        }
    }
    
    public void setErroRegulagemMinima(Object value) {
        aErroRegulagemMinima.setValue(value);
        if (aErroRegulagemMinima.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyErroRegulagemMinima() {
        if (!aErroRegulagemMinima.isNull()) {
            aErroRegulagemMinima.setNull(true);
            setModified(true);
        }
    }
    
    public DomPercent getErroRegulagemMinima() {
        return aErroRegulagemMinima;
    }
    
    public DomPercent oldErroRegulagemMinima() {
        return oErroRegulagemMinima;
    }
    
    public Double valueOfErroRegulagemMinima() {
        return aErroRegulagemMinima.getValue();
    }
    
    public boolean isErroRegulagemMinimaModified() {
        return aErroRegulagemMinima.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ERRO_REGULAGEM_MAXIMA">
    
    public EntPontoExecucao erroRegulagemMaxima(Double value) {
        setErroRegulagemMaxima(value);
        return this;
    }
    
    public void setErroRegulagemMaxima(DomPercent value) {
        if (value == null || value.isNull()) {
            nullifyErroRegulagemMaxima();
        } else {
            aErroRegulagemMaxima.setValue(value.getValue());
            if (aErroRegulagemMaxima.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setErroRegulagemMaxima(String value) {
        if (value == null) {
            nullifyErroRegulagemMaxima();
        } else {
            aErroRegulagemMaxima.setValue(value);
            if (aErroRegulagemMaxima.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setErroRegulagemMaxima(Double value) {
        aErroRegulagemMaxima.setValue(value);
        if (aErroRegulagemMaxima.isModified()) {
            setModified(true);
        }
    }
    
    public void setErroRegulagemMaxima(Object value) {
        aErroRegulagemMaxima.setValue(value);
        if (aErroRegulagemMaxima.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyErroRegulagemMaxima() {
        if (!aErroRegulagemMaxima.isNull()) {
            aErroRegulagemMaxima.setNull(true);
            setModified(true);
        }
    }
    
    public DomPercent getErroRegulagemMaxima() {
        return aErroRegulagemMaxima;
    }
    
    public DomPercent oldErroRegulagemMaxima() {
        return oErroRegulagemMaxima;
    }
    
    public Double valueOfErroRegulagemMaxima() {
        return aErroRegulagemMaxima.getValue();
    }
    
    public boolean isErroRegulagemMaximaModified() {
        return aErroRegulagemMaxima.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CAMPO_MEDICAO">
    
    public EntPontoExecucao campoMedicao(String value) {
        setCampoMedicao(value);
        return this;
    }
    
    public void setCampoMedicao(DomOption value) {
        if (value == null || value.isNull()) {
            nullifyCampoMedicao();
        } else {
            aCampoMedicao.setValue(value.getValue());
            if (aCampoMedicao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCampoMedicao(String value) {
        if (value == null) {
            nullifyCampoMedicao();
        } else {
            aCampoMedicao.setValue(value);
            if (aCampoMedicao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCampoMedicao(Object value) {
        aCampoMedicao.setValue(value);
        if (aCampoMedicao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCampoMedicao() {
        if (!aCampoMedicao.isNull()) {
            aCampoMedicao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOption getCampoMedicao() {
        return aCampoMedicao;
    }
    
    public DomOption oldCampoMedicao() {
        return oCampoMedicao;
    }
    
    public String valueOfCampoMedicao() {
        return aCampoMedicao.getValue();
    }
    
    public boolean isCampoMedicaoModified() {
        return aCampoMedicao.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.CLASSE_VOLUME_VAZAO_TEMPO.FK_TAXVAZ_PONTO_EXECUCAO
        {
            EntClasseVolumeVazaoTempo external = new EntClasseVolumeVazaoTempo(ctx);
            external.findByPontoExecucao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.CLASSE_VOLUME_VAZAO_TEMPO.FK_TAXVAZ_PONTO_EXECUCAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Volumes para cálculos de vazões (tempo) fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PONTO_EXECUCAO
        {
            EntPontoPlanoExecucao external = new EntPontoPlanoExecucao(ctx);
            external.findByPontoExecucao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PONTO_EXECUCAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Pontos utilizados nos planos de execuções fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_TAXVAZ_PONTO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.CLASSE_VOLUME_VAZAO_TEMPO.FK_TAXVAZ_PONTO_EXECUCAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Volumes para cálculos de vazões (tempo) fazendo referencia para este registro! (FK_TAXVAZ_PONTO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_PUNPEX_PONTO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PONTO_EXECUCAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Pontos utilizados nos planos de execuções fazendo referencia para este registro! (FK_PUNPEX_PONTO_EXECUCAO)");
                return e;
            } else {
                e = new AdsException("ZTEST.PONTO_EXECUCAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("UK_PONEXC_SIGLA") >= 0) {
                e = new AdsException("ZTEST.PONTO_EXECUCAO.UK_PONEXC_SIGLA", 
                        Severity.ERROR,
                        "Registro duplicado! Sigla do ponto de ensaio deve ser único. Sigla do ponto de ensaio ${SIGLA} (UK_PONEXC_SIGLA)");
                return e;
            } else if (msg.indexOf("PK_PONEXC") >= 0) {
                e = new AdsException("ZTEST.PONTO_EXECUCAO.PK_PONEXC", 
                        Severity.ERROR,
                        "ID duplicado! (PK_PONEXC)");
                return e;
            } else {
                e = new AdsException("ZTEST.PONTO_EXECUCAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aSigla);
            allAttributes.add(aDescricao);
            allAttributes.add(aErroRegulagemMinima);
            allAttributes.add(aErroRegulagemMaxima);
            allAttributes.add(aCampoMedicao);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getSigla().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findBySigla(String sigla) throws AdsException {
        findBy(new String[] {"SIGLA"},
                new Object[] {sigla});
    }
    /**
     * Retorna os registros de CLASSE_VOLUME_VAZAO_TEMPO que referenciam este registro através do atributo PONTO_EXECUCAO_ID
     */
    public EntClasseVolumeVazaoTempo findAllClasseVolumeVazaoTempoPontoExecucao() throws AdsException {
        return findAllClasseVolumeVazaoTempoPontoExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de CLASSE_VOLUME_VAZAO_TEMPO que referenciam este registro através do atributo PONTO_EXECUCAO_ID
     */
    public EntClasseVolumeVazaoTempo findAllClasseVolumeVazaoTempoPontoExecucao(String sqlAppend) throws AdsException {
        EntClasseVolumeVazaoTempo out = new EntClasseVolumeVazaoTempo(ctx);
        out.find("select ID from CLASSE_VOLUME_VAZAO_TEMPO where PONTO_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de PONTO_PLANO_EXECUCAO que referenciam este registro através do atributo PONTO_EXECUCAO_ID
     */
    public EntPontoPlanoExecucao findAllPontoPlanoExecucaoPontoExecucao() throws AdsException {
        return findAllPontoPlanoExecucaoPontoExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de PONTO_PLANO_EXECUCAO que referenciam este registro através do atributo PONTO_EXECUCAO_ID
     */
    public EntPontoPlanoExecucao findAllPontoPlanoExecucaoPontoExecucao(String sqlAppend) throws AdsException {
        EntPontoPlanoExecucao out = new EntPontoPlanoExecucao(ctx);
        out.find("select ID from PONTO_PLANO_EXECUCAO where PONTO_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oCampoMedicao.setValue(aCampoMedicao);
        oSigla.setValue(aSigla);
        oErroRegulagemMinima.setValue(aErroRegulagemMinima);
        oErroRegulagemMaxima.setValue(aErroRegulagemMaxima);
        oDescricao.setValue(aDescricao);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntPontoExecucao.class);
            rule.setName("PK_PONEXC");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntPontoExecucao.class);
            rule.setName("UK_PONEXC_SIGLA");
            rule.addAttribute(new DomText("SIGLA",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntPontoExecucao.class);
            rule.setCheckAttribute(new DomOption("CAMPO_MEDICAO",""));
            rule.setName("CKAV_22046624");
            rule.addAllowableValues(new String[] {"S", "I"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
